home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1998 March / Macworld (1998-03) (Disk 1).dmg / Shareware World / Utilities / Text Processing / Alpha / Tcl / Modes / latex Mode / latexMacros.tcl < prev    next >
Encoding:
Text File  |  1997-12-08  |  50.0 KB  |  1,889 lines  |  [TEXT/ALFA]
  1. #############################################################################
  2. #############################################################################
  3. #
  4. # latexMacros.tcl (called from latex.tcl)
  5. #
  6. #############################################################################
  7. #
  8. # Author:  Tom Scavo <trscavo@syr.edu>
  9. #
  10. #############################################################################
  11. #############################################################################
  12.  
  13. proc latexMacros.tcl {} {}
  14.  
  15. #############################################################################
  16. # 
  17. # Basic Commands
  18. #
  19. #############################################################################
  20.  
  21. #--------------------------------------------------------------------------
  22. # Utilities:
  23. #--------------------------------------------------------------------------
  24.  
  25. # A keyboard-bound method of accessing menu commands.  Takes a list of 
  26. # menu items (i.e., the tail of a 'menu' command), the menu name (the 
  27. # argument of the '-n' switch) , and the name of a menu filter (the 
  28. # argument of the '-p' switch) as input, and displays these items in a 
  29. # list box.  If the chosen item is a menu command (as opposed to a 
  30. # submenu), it is passed to the menu filter; otherwise, 'chooseCommand' 
  31. # recursively calls itself until a menu command is chosen or the cancel 
  32. # button is pressed.
  33. #
  34. proc chooseCommand {menuItems {menuName ""} {menuFilterProc ""} {level 1}} {
  35.     watchCursor
  36.     if { $menuItems == "" } { return }
  37.     # Preprocess the list of menu items:
  38.     foreach    item $menuItems {
  39.         regsub -all {[<!/].} $item {} item
  40.         regsub -all {…}    $item {} item
  41.         lappend    menOut $item
  42.         if { [string match "menu*" $item] } {
  43.             if { [set ind [lsearch $item {-n}]] >= 0 } {
  44.                 lappend    top "[lindex $item [incr    ind]]:"
  45.             }
  46.         } elseif { ![string match "(*" $item] } {
  47.             lappend    top $item
  48.         }
  49.     }
  50.     # Present the menu items to the user:
  51.     set res    [listpick -p "Choose menu command (level $level):" $top]
  52.     # Either execute a command or recurse on a submenu:
  53.     if { [lsearch $menOut $res] >= 0 } {
  54.         # Execute the command via the menu filter, if necessary:
  55.         if { $menuFilterProc == "" } {
  56.             $res
  57.         } else {
  58.             $menuFilterProc $menuName $res
  59.         }
  60.     } else {
  61.         set res [string trimright $res {:}]
  62.         foreach    item $menOut {
  63.             if { [lsearch $item $res] >= 0 } {
  64.                 set menuItems [lindex $item end]
  65.                 # Determine the name of this submenu:
  66.                 if { [set ind [lsearch $item {-n}]] >= 0 } {
  67.                     set menuName [lindex $item [incr ind]]
  68.                 } else {
  69.                     set menuName ""
  70.                 }
  71.                 # Determine the name of the menu filter for this submenu:
  72.                 if { [set ind [lsearch $item {-p}]] >= 0 } {
  73.                     set menuFilterProc [lindex $item [incr ind]]
  74.                 } else {
  75.                     set menuFilterProc ""
  76.                 }
  77.                 return [chooseCommand $menuItems $menuName $menuFilterProc [incr level]]
  78.             }
  79.         }
  80.     }
  81. }
  82.  
  83. # A keyboard-bound method of inserting environments.
  84. #
  85. proc chooseEnvironment {} {
  86.     set env [getEnvironment]
  87.     if { [catch {eval $env}] } {
  88.         doWrapEnvironment $env
  89.     }
  90. }
  91. proc getEnvironment {} {
  92.     if { [catch {prompt "Choose environment:" "abstract" "" \
  93.                  "abstract" \
  94.                  "array" \
  95.                  "center" \
  96.                  "description" \
  97.                  "displaymath" \
  98.                  "document" \
  99.                  "enumerate" \
  100.                  "eqnarray" \
  101.                  "eqnarray*" \
  102.                  "equation" \
  103.                  "figure" \
  104.                  "filecontents" \
  105.                  "flushleft" \
  106.                  "flushright" \
  107.                  "itemize" \
  108.                  "math" \
  109.                  "minipage" \
  110.                  "note" \
  111.                  "overlay" \
  112.                  "quotation" \
  113.                  "quote" \
  114.                  "slide" \
  115.                  "table" \
  116.                  "tabular" \
  117.                  "thebibliography" \
  118.                  "titlepage" \
  119.                  "verbatim" \
  120.                  "verse" \
  121.                 } env] } {
  122.         set env ""
  123.     }
  124.     return $env
  125. }
  126.  
  127.  
  128. #############################################################################
  129. # 
  130. # Paragraph Mode Macros
  131. #
  132. #############################################################################
  133.  
  134. #--------------------------------------------------------------------------
  135. # Documents:
  136. #--------------------------------------------------------------------------
  137.  
  138. proc newLaTeXDocument {} {
  139.     catch {prompt "Choose a documentclass:" "article" "" "article" \
  140.             "report" "book" "letter" "slides"} documentType
  141.     if {$documentType != "cancel"} {
  142.         new -m TeX
  143.         if { [catch {${documentType}Documentclass}] } {
  144.             wrapDocument "$documentType" 
  145.         }
  146.         while { [options] } {}
  147.         message "enter option (or leave blank)"
  148.     }
  149. }
  150.  
  151. proc letterDocumentclass {} {
  152.     set    preamble "\r\\address\{%\r"
  153.     append preamble "    ••    \\\\    % insert your name here\r"
  154.     append preamble "    ••    \\\\    % insert your address here\r"
  155.     append preamble "    ••    \\\\    % insert more address here\r"
  156.     append preamble "    ••          % insert city-state-zip here\r"
  157.     append preamble "\}\r\r"
  158.     append preamble "\\date\{••\}  % optional\r"
  159.     append preamble "\\signature\{••\}\r\r"
  160.     set    body     "\r\\begin\{letter\}\{%\r"
  161.     append body     "    ••    \\\\    % insert addressee's name here\r"
  162.     append body     "    ••    \\\\    % insert addressee's address here\r"
  163.     append body     "    ••    \\\\    % insert more address here\r"
  164.     append body     "    ••          % insert addressee's city-state-zip here\r"
  165.     append body     "\}\r\r"
  166.     append body     "\\opening\{Dear ••,\}\r\r"
  167.     if {[isEmptyFile]} {
  168.         append body "% BODY OF LETTER\r"
  169.         append body "••\r\r"
  170.     } else {
  171.         if {[isSelectionAll]} {
  172.             set text [getSelect]
  173. #             deleteText 0 [maxPos]
  174.             append body "$text\r"
  175.         } else {
  176.             alertnote "nonempty file:  delete text or \'Select All\'\
  177.                 from the Edit menu"
  178.             return
  179.         }
  180.     }
  181.     append body "\\closing\{Sincerely,\}\r\r"
  182.     append body "\\encl\{••\}\r"
  183.     append body "\\cc\{••\}\r\r"
  184.     append body "\\end\{letter\}\r\r"
  185.     insertDocument "letter" $preamble $body
  186.     message "enter option (or leave blank)"
  187. }
  188. proc articleDocumentclass {} {
  189.     if { [wrapDocument "article"] } {
  190.         message "enter option (or leave blank)"
  191.     }
  192. }
  193. proc reportDocumentclass {} {
  194.     if { [wrapDocument "report"] } {
  195.         message "enter option (or leave blank)"
  196.     }
  197. }
  198. proc bookDocumentclass {} {
  199.     if { [wrapDocument "book"] } {
  200.         message "enter option (or leave blank)"
  201.     }
  202. }
  203. proc slidesDocumentclass {} {
  204.     if { [wrapDocument "slides"] } {
  205.         message "enter option (or leave blank)"
  206.     }
  207. }
  208. proc otherDocumentclass {} {
  209.     catch {prompt "What documentclass?" "article"} documentType
  210.     if {$documentType != "cancel"} {
  211.         if { [wrapDocument "$documentType"] } {
  212.             message "enter option (or leave blank)"
  213.         }
  214.     }
  215. }
  216.  
  217. # If an option is inserted, return true; otherwise, return false.
  218. proc options {} {
  219.     set option [getOption]
  220.     if {$option != ""} {
  221.         insertOption $option
  222.         return 1
  223.     }
  224.     return 0
  225. }
  226. proc getOption {} {
  227.     catch {prompt "Choose an option:" "11pt" "" "10pt" "11pt" "12pt" "(-" \
  228.             "letterpaper" "legalpaper" "executivepaper" "a4paper" "a5paper" \
  229.             "b5paper" "(-" "landscape" "(-" "final" "draft" "(-" \
  230.             "oneside" "twoside" "(-" "openright" "openany" "(-" \
  231.             "onecolumn" "twocolumn" "(-" "notitlepage" "titlepage" \
  232.                   "openbib" "(-" "leqno" "(-" "fleqn"} optionName
  233.     if {$optionName != "cancel"} {
  234.         return $optionName
  235.     } else {
  236.         return ""
  237.     }
  238. }
  239. proc insertOption {option} {
  240.     global TeXmodeVars
  241.     set searchString {\\documentclass}
  242.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  243.     if {[llength $searchResult] == 0} {
  244.         if { $TeXmodeVars(searchNoisily) } {beep}
  245.         message "can\'t find \\documentclass"
  246.     } else {
  247.         set nextCharPos [lindex $searchResult 1]
  248.         goto $nextCharPos
  249.         set nextChar [lookAt $nextCharPos]
  250.         if {$nextChar == "\["} {
  251.             forwardChar
  252.             insertText $option
  253.             if {[lookAt [getPos]] != "\]"} {
  254.                 insertText ","
  255.             }
  256.         } elseif {$nextChar == "\{"} {
  257.             insertText "\[$option\]"
  258.         } else {
  259.             alertnote "unrecognizable \\documentclass statement"
  260.         }
  261.     }
  262. }
  263.  
  264. proc insertPackage {package} {
  265.     global TeXmodeVars
  266.     # Check to see if $package is already loaded:
  267.     if { $package != "" } {
  268.         append searchString {^[^%]*\\usepackage\{.*} $package {.*\}}
  269.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  270.         if {[llength $searchResult] != 0} {
  271.             if { $TeXmodeVars(searchNoisily) } {beep}
  272.             message "$package package already loaded"
  273.             return
  274.         }
  275.     }
  276.     # Newlines are allowed in the arguments of \documentclass:
  277.     set searchString {\\documentclass(\[[^][]*\])?{[^{}]*}}
  278.     # Search for \documentclass command:
  279.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  280.     if {[llength $searchResult] == 0} {
  281.         if { $TeXmodeVars(searchNoisily) } {beep}
  282.         message "can't find \\documentclass"
  283.     } else {
  284.         pushPosition
  285.         goto [lindex $searchResult 1]
  286.         set txt "\r\\usepackage\{$package\}"
  287.         insertText $txt
  288.         backwardChar
  289.         message "Press <Ctl .> to return to previous position"
  290.     }
  291. }
  292.  
  293. proc filecontents {} {
  294.     global searchNoisily
  295.     set searchString {\\documentclass}
  296.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  297.     if {[llength $searchResult] == 0} {
  298.         if {$searchNoisily} {beep}
  299.         message "can\'t find \\documentclass"
  300.         return
  301.     } else {
  302.         set prompt "File to be included:"
  303.         if {[catch {getfile $prompt} path]} {
  304.             return
  305.         } else {
  306.             replaceText 0 0 [buildFilecontents $path]
  307.             goto 0
  308.             message "file included"
  309.         }
  310.     }
  311. }
  312. proc filecontentsAll {} {
  313.     global searchNoisily
  314.     watchCursor
  315.     message "locating all input files…"
  316.     set currentWin [win::Current]
  317.     # Is the current window part of TeX fileset?
  318.     set fset [isWindowInFileset $currentWin "tex"]
  319.     if { $fset == "" } {
  320.         set searchString {\\documentclass}
  321.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  322.         if {[llength $searchResult] == 0} {
  323.             if {$searchNoisily} {beep}
  324.             message "can\'t find \\documentclass"
  325.             return
  326.         } else {
  327.             set text [getText 0 [maxPos]]
  328.         }
  329.     } else {
  330.         # Will not handle a base file that is open and dirty:
  331.         set text [buildFilecontents [texFilesetBaseName $fset]]
  332.     }
  333.     set currentDir [file dirname $currentWin]
  334.     set newText [texResolveAll $text $currentDir]
  335.     if { [string length $text] == [string length $newText] } {
  336.         beep
  337.         message "no files to include"
  338.     } else {
  339.         replaceText 0 [maxPos] $newText
  340.         goto 0
  341.         message "all files included"
  342.     }
  343. }
  344. # Takes a LaTeX document string and a path as input, and returns
  345. # a modified document string with all filecontents environments
  346. # prepended.
  347. proc texResolveAll {latexDoc currentDir} {
  348.     global TeXmodeVars
  349.     set pairs [list \
  350.                 {{\\documentclass} {.cls}} {{\\LoadClass} {.cls}} \
  351.                 {{\\include} {.tex}} \
  352.                 {{\\usepackage} {.sty}} {{\\RequirePackage} {.sty}} \
  353.                 {{\\input} {}} \
  354.                 {{\\bibliography} {.bib}} {{\\bibliographystyle} {.bst}} \
  355.               ]
  356.     foreach macro $TeXmodeVars(boxMacroNames) {
  357.         regsub {\*} $macro {\\*} macro
  358.         lappend pairs [list \\\\$macro {}]
  359.     }
  360.     foreach pair $pairs {
  361.         set cmd [car $pair]
  362.         set ext [cadr $pair]
  363.         set searchString $cmd
  364.         append searchString {(\[[^][]*\])?{([^{}]*)}}
  365.         set searchText $latexDoc
  366.         while { [regexp -indices $searchString $searchText mtch dummy theArgs] } {
  367.             set begPos [lindex $theArgs 0]
  368.             set endPos [lindex $theArgs 1]
  369.             set args [string range $searchText $begPos $endPos]
  370.             foreach arg [split $args ,] {
  371.                 if { $cmd == {\\input} && ![string length [file extension $arg]] } {
  372.                     set ext {.tex}
  373.                 }
  374.                 set files [glob -nocomplain $currentDir:$arg*]
  375.                 set filename "$currentDir:$arg$ext"
  376.                 if { [lsearch -exact $files $filename] > -1 } {
  377.                     set tempDoc $latexDoc
  378.                     set latexDoc [buildFilecontents $filename]
  379.                     append latexDoc $tempDoc
  380.                 }
  381.             }
  382.             set searchText [string range $searchText [expr $endPos + 2] end]
  383.         }
  384.     }
  385.     return $latexDoc
  386. }
  387. # Takes a filename as input and returns a filecontents environment 
  388. # based on the contents of that file.  If a second argument is given,
  389. # use that as the argument of the filecontents environment instead
  390. # of the original filename.
  391. proc buildFilecontents {filename {newFilename {}}} {
  392.     set text [readFile $filename]
  393.     # Fix end-of-line characters:
  394.     regsub -all "\xa" $text "\xd" text
  395.     set envName "filecontents"
  396.     if { $newFilename == {} } {
  397.         set envArg "{[file tail $filename]}"
  398.     } else {
  399.         set envArg "{$newFilename}"
  400.     }
  401.     return [buildEnvironment $envName $envArg "$text\r" "\r\r"]
  402. }
  403.  
  404. #--------------------------------------------------------------------------
  405. # Page Layout:
  406. #--------------------------------------------------------------------------
  407.  
  408. proc maketitle {} {
  409.     global searchNoisily
  410.     set searchString {\\document(class|style)(\[.*\])?\{.*\}}
  411.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString 0]
  412.     if {[llength $searchResult] == 0} {
  413.         if {$searchNoisily} {beep}
  414.         message "can\'t find \\documentclass or \\documentstyle"
  415.     } else {
  416.         set searchPos [lindex $searchResult 1]
  417.         set searchString {\\begin\{document\}}
  418.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 $searchString $searchPos]
  419.         if {[llength $searchResult] == 0} {
  420.             if {$searchNoisily} {beep}
  421.             message "can\'t find \\begin\{document\}"
  422.         } else {
  423.             goto [lindex $searchResult 1]
  424.             set currentPos [getPos]
  425.             set txt "\r\r% Definition of title page:"
  426.             append txt "\r\\title\{"
  427.             append txt "\r\t••\r\}"
  428.             append txt "\r\\author\{"
  429.             append txt "\r\t••\t% insert author(s) here"
  430.             append txt "\r\}"
  431.             append txt "\r\\date\{••\}\t% optional"
  432.             append txt "\r\r\\maketitle"
  433.             elec::Insertion $txt
  434.             message "insert title"
  435.         }
  436.     }
  437. }
  438. proc abstract {} { doWrapEnvironment "abstract" }
  439. proc titlepage {} { doWrapEnvironment "titlepage" }
  440. proc getPagestyle {} {
  441.     catch {prompt "Choose a pagestyle:" "plain" "" "plain" "empty" \
  442.                   "headings" "myheadings"} pagestyleName
  443.     if {$pagestyleName != "cancel"} {
  444.         return $pagestyleName
  445.     } else {
  446.         return ""
  447.     }
  448. }
  449. proc pagestyle {} {
  450.     set pagestyleName [getPagestyle]
  451.     if {$pagestyleName != ""} {
  452.         openingCarriageReturn
  453.         insertObject "\\pagestyle\{$pagestyleName\}"
  454.         closingCarriageReturn
  455.     }
  456. }
  457. proc thispagestyle {} {
  458.     set pagestyleName [getPagestyle]
  459.     if {$pagestyleName != ""} {
  460.         openingCarriageReturn
  461.         insertObject "\\thispagestyle\{$pagestyleName\}"
  462.         closingCarriageReturn
  463.     }
  464. }
  465. proc getPagenumberingStyle {} {
  466.     catch {prompt "Choose a pagenumbering style:" "arabic" "" "arabic" \
  467.                   "roman" "Roman" "alph" "Alph"} pagenumberingStyle
  468.     if {$pagenumberingStyle != "cancel"} {
  469.         return $pagenumberingStyle
  470.     } else {
  471.         return ""
  472.     }
  473. }
  474. proc pagenumbering {} {
  475.     set pagenumberingStyle [getPagenumberingStyle]
  476.     if {$pagenumberingStyle != ""} {
  477.         openingCarriageReturn
  478.         insertObject "\\pagenumbering\{$pagenumberingStyle\}"
  479.         closingCarriageReturn
  480.     }
  481. }
  482. proc twocolumn {} {
  483.     openingCarriageReturn
  484.     insertObject "\\twocolumn"
  485.     closingCarriageReturn
  486. }
  487. proc onecolumn {} {
  488.     openingCarriageReturn
  489.     insertObject "\\onecolumn"
  490.     closingCarriageReturn
  491. }
  492.  
  493. #--------------------------------------------------------------------------
  494. # Sectioning:
  495. #--------------------------------------------------------------------------
  496.  
  497. proc sectioning {item} {
  498.     append left [openingCarriageReturn] "\\${item}\{"
  499.     append right "\}"
  500.     if [regexp (part|chapter) $item] {
  501.         append right "\\thispagestyle{empty}"
  502.     }
  503.     append right "••" [closingCarriageReturn]
  504.     if [wrapObject $left $right] {
  505.         message "don't forget the label <Ctl Opt L>"
  506.     } else {
  507.         message "type the [string trim $item {*}] name and don't forget the label <Ctl Opt L>"
  508.     }
  509. }
  510.  
  511. proc appendix {} {
  512.     insertObject "[openingCarriageReturn]\\appendix[closingCarriageReturn]"
  513. }
  514.  
  515. #--------------------------------------------------------------------------
  516. # Text Style:
  517. #--------------------------------------------------------------------------
  518.  
  519. proc emph {} {
  520.     if {[wrapObject "\\emph{" "}••"]} {
  521.         message "selected text has been emphasized"
  522.     } else {
  523.         message "enter text to be emphasized"
  524.     }
  525. }
  526. proc textup {} {
  527.     if {[wrapObject "\\textup{" "}••"]} {
  528.         message "selected text has upright shape"
  529.     } else {
  530.         message "enter text to have upright shape"
  531.     }
  532. }
  533. proc textit {} {
  534.     if {[wrapObject "\\textit{" "}••"]} {
  535.         message "selected text has italic shape"
  536.     } else {
  537.         message "enter text to have italic shape"
  538.     }
  539. }
  540. proc textsl {} {
  541.     if {[wrapObject "\\textsl{" "}••"]} {
  542.         message "selected text has slanted shape"
  543.     } else {
  544.         message "enter text to have slanted shape"
  545.     }
  546. }
  547. proc textsc {} {
  548.     if {[wrapObject "\\textsc{" "}••"]} {
  549.         message "selected text has small caps shape"
  550.     } else {
  551.         message "enter text to have small caps shape"
  552.     }
  553. }
  554. proc textmd {} {
  555.     if {[wrapObject "\\textmd{" "}••"]} {
  556.         message "selected text has been set in medium series"
  557.     } else {
  558.         message "enter text to be set in medium series"
  559.     }
  560. }
  561. proc textbf {} {
  562.     if {[wrapObject "\\textbf{" "}••"]} {
  563.         message "selected text has been set in bold series"
  564.     } else {
  565.         message "enter text to be set in bold series"
  566.     }
  567. }
  568. proc textrm {} {
  569.     if {[wrapObject "\\textrm{" "}••"]} {
  570.         message "selected text has been set with roman family"
  571.     } else {
  572.         message "enter text to be set using roman family"
  573.     }
  574. }
  575. proc textsf {} {
  576.     if {[wrapObject "\\textsf{" "}••"]} {
  577.         message "selected text has been set with sans serif family"
  578.     } else {
  579.         message "enter text to be set using sans serif family"
  580.     }
  581. }
  582. proc texttt {} {
  583.     if {[wrapObject "\\texttt{" "}••"]} {
  584.         message "selected text has been set with typewriter family"
  585.     } else {
  586.         message "enter text to be set using typewriter family"
  587.     }
  588. }
  589. proc textnormal {} {
  590.     if {[wrapObject "\\textnormal{" "}••"]} {
  591.         message "selected text has been set with normal style"
  592.     } else {
  593.         message "enter text to be set using normal style"
  594.     }
  595. }
  596.  
  597. proc em {} {
  598.     if {[wrapObject "{\\em " "}••"]} {
  599.         message "emphasized text set"
  600.     } else {
  601.         message "enter text to be emphasized"
  602.     }
  603. }
  604. proc upshape {} {
  605.     if {[wrapObject "{\\upshape " "}••"]} {
  606.         message "text set in upright shape"
  607.     } else {
  608.         message "enter text to be set in upright shape"
  609.     }
  610. }
  611. proc itshape {} {
  612.     if {[wrapObject "{\\itshape " "}••"]} {
  613.         message "text set in italics shape"
  614.     } else {
  615.         message "enter text to be set in italics shape"
  616.     }
  617. }
  618. proc slshape {} {
  619.     if {[wrapObject "{\\slshape " "}••"]} {
  620.         message "text set in slanted shape"
  621.     } else {
  622.         message "enter text to be set in slanted shape"
  623.     }
  624. }
  625. proc scshape {} {
  626.     if {[wrapObject "{\\scshape " "}••"]} {
  627.         message "text set in small caps shape"
  628.     } else {
  629.         message "enter text to be set in small caps shape"
  630.     }
  631. }
  632. proc mdseries {} {
  633.     if {[wrapObject "{\\mdseries " "}••"]} {
  634.         message "text set in medium series"
  635.     } else {
  636.         message "enter text to be set in medium series"
  637.     }
  638. }
  639. proc bfseries {} {
  640.     if {[wrapObject "{\\bfseries " "}••"]} {
  641.         message "text set in bold series"
  642.     } else {
  643.         message "enter text to be set in bold series"
  644.     }
  645. }
  646. proc rmfamily {} {
  647.     if {[wrapObject "{\\rmfamily " "}••"]} {
  648.         message "text set in roman family"
  649.     } else {
  650.         message "enter text to be set in roman family"
  651.     }
  652. }
  653. proc sffamily {} {
  654.     if {[wrapObject "{\\sffamily " "}••"]} {
  655.         message "text set in sans serif family"
  656.     } else {
  657.         message "enter text to be set in sans serif family"
  658.     }
  659. }
  660. proc ttfamily {} {
  661.     if {[wrapObject "{\\ttfamily " "}••"]} {
  662.         message "text set in typewriter family"
  663.     } else {
  664.         message "enter text to be set in typewriter family"
  665.     }
  666. }
  667. proc normalfont {} {
  668.     if {[wrapObject "{\\normalfont " "}••"]} {
  669.         message "text set in normal style"
  670.     } else {
  671.         message "enter text to be set in normal style"
  672.     }
  673. }
  674.  
  675. #--------------------------------------------------------------------------
  676. # Text Size:
  677. #--------------------------------------------------------------------------
  678.  
  679. proc doTextSize {textSize} {
  680.     if {[wrapObject "{\\$textSize " "}••"]} {
  681.         message "$textSize text set"
  682.     } else {
  683.         message "enter $textSize text"
  684.     }
  685. }
  686.  
  687. #--------------------------------------------------------------------------
  688. # Text Commands:
  689. #--------------------------------------------------------------------------
  690.  
  691. proc textsuperscript {} {
  692.     if {[wrapObject "\\textsuperscript{" "}••"]} {
  693.         message "text superscripted"
  694.     } else {
  695.         message "enter superscripted text"
  696.     }
  697. }
  698. proc textcircled {} {
  699.     if {[wrapObject "\\textcircled{" "}••"]} {
  700.         message "text circled"
  701.     } else {
  702.         message "enter circled text"
  703.     }
  704. }
  705.  
  706. #--------------------------------------------------------------------------
  707. # International:
  708. #--------------------------------------------------------------------------
  709.  
  710. proc {ò} {} {
  711.     if {[wrapObject "\\`{" "}••"]} {
  712.         message "accent set"
  713.     } else {
  714.         message "enter single character"
  715.     }
  716. }
  717. proc {ó} {} {
  718.     if {[wrapObject "\\'{" "}••"]} {
  719.         message "accent set"
  720.     } else {
  721.         message "enter single character"
  722.     }
  723. }
  724. proc {ô} {} {
  725.     if {[wrapObject "\\^{" "}••"]} {
  726.         message "accent set"
  727.     } else {
  728.         message "enter single character"
  729.     }
  730. }
  731. proc {ö} {} {
  732.     if {[wrapObject "\\\"{" "}••"]} {
  733.         message "accent set"
  734.     } else {
  735.         message "enter single character"
  736.     }
  737. }
  738. proc {õ} {} {
  739.     if {[wrapObject "\\~{" "}••"]} {
  740.         message "accent set"
  741.     } else {
  742.         message "enter single character"
  743.     }
  744. }
  745. proc {ç} {} {insertObject "\\c\{c\}"}
  746. proc {Ç} {} {insertObject "\\c\{C\}"}
  747. proc {œ} {} {insertObject "\\oe"}
  748. proc {Œ} {} {insertObject "\\OE"}
  749. proc {æ} {} {insertObject "\\ae"}
  750. proc {Æ} {} {insertObject "\\AE"}
  751. proc {å} {} {insertObject "\\aa"}
  752. proc {Å} {} {insertObject "\\AA"}
  753. proc {ø} {} {insertObject "\\o"}
  754. proc {Ø} {} {insertObject "\\O"}
  755. proc {ss} {} {insertObject "\\ss"}
  756. proc {SS} {} {insertObject "\\SS"}
  757. proc {¿} {} {insertObject "?`"}
  758. proc {¡} {} {insertObject "!`"}
  759.  
  760. #--------------------------------------------------------------------------
  761. # Environments:
  762. #--------------------------------------------------------------------------
  763.  
  764. proc enumerate {} {
  765.     global promptNoisily useStatusBar
  766.     set envName "enumerate"
  767.     if {$promptNoisily && $useStatusBar} {beep}
  768.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  769.     if {$numberItems == "cancel"} {
  770.         return
  771.     } elseif {![isPositiveInteger $numberItems]} {
  772.         beep
  773.         message "invalid input:  unsigned, postive integer required"
  774.         return
  775.     }
  776.     if {$numberItems} {
  777.         set body "\t\\item  ••"
  778.         for {set i 1} {$i < $numberItems} {incr i} {
  779.             append body "\r\r\t\\item  ••"
  780.         }
  781.         append body "\r"
  782.     } else {
  783.         set body "\t••\r"
  784.     }
  785.     if {[insertEnvironment $envName "" $body]} {
  786.         message "type first item"
  787.     }
  788. }
  789. proc itemize {} {
  790.     global promptNoisily useStatusBar
  791.     set envName "itemize"
  792.     if {$promptNoisily && $useStatusBar} {beep}
  793.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  794.     if {$numberItems == "cancel"} {
  795.         return
  796.     } elseif {![isPositiveInteger $numberItems]} {
  797.         beep
  798.         message "invalid input:  unsigned, postive integer required"
  799.         return
  800.     }
  801.     if {$numberItems} {
  802.         set body "\t\\item  ••"
  803.         for {set i 1} {$i < $numberItems} {incr i} {
  804.             append body "\r\r\t\\item  ••"
  805.         }
  806.         append body "\r"
  807.     } else {
  808.         set body "\t••\r"
  809.     }
  810.     if {[insertEnvironment $envName "" $body]} {
  811.         message "type first item"
  812.     }
  813. }
  814. proc description {} {
  815.     global promptNoisily useStatusBar
  816.     set envName "description"
  817.     if {$promptNoisily && $useStatusBar} {beep}
  818.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  819.     if {$numberItems == "cancel"} {
  820.         return
  821.     } elseif {![isPositiveInteger $numberItems]} {
  822.         beep
  823.         message "invalid input:  unsigned, postive integer required"
  824.         return
  825.     }
  826.     if {$numberItems} {
  827.         set body "\t\\item\[••\]  ••"
  828.         for {set i 1} {$i < $numberItems} {incr i} {
  829.             append body "\r\r\t\\item\[••\]  ••"
  830.         }
  831.         append body "\r"
  832.     } else {
  833.         set body "\t••\r"
  834.     }
  835.     if {[insertEnvironment $envName "" $body]} {
  836.         message "type first item label"
  837.     }
  838. }
  839. proc thebibliography {} {
  840.     global promptNoisily useStatusBar
  841.     set envName "thebibliography"
  842.     if {$promptNoisily && $useStatusBar} {beep}
  843.     catch {sPrompt "$envName:  how many items?" 3} numberItems
  844.     if {$numberItems == "cancel"} {
  845.         return
  846.     } elseif {![isPositiveInteger $numberItems]} {
  847.         beep
  848.         message "invalid input:  unsigned, postive integer required"
  849.         return
  850.     }
  851.     set arg "{9}"
  852.     if {$numberItems} {
  853.         if {$numberItems > 9} {set arg "{99}"}
  854.         set body "\t\\bibitem{••}  ••"
  855.         for {set i 1} {$i < $numberItems} {incr i} {
  856.             append body "\r\r\t\\bibitem{••}  ••"
  857.         }
  858.         append body "\r"
  859.     } else {
  860.         set body "\t••\r"
  861.     }
  862.     if {[insertEnvironment $envName $arg $body]} {
  863.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {(9)+} [getPos]]
  864.         eval select $searchResult
  865.         message "Change the length of the key field?"
  866.     }
  867. }
  868. proc slide {} { doWrapEnvironment "slide" }
  869. proc overlay {} { doWrapEnvironment "overlay" }
  870. proc note {} { doWrapEnvironment "note" }
  871. proc figure {} {
  872.     global TeXmodeVars
  873.     set envName "figure"
  874.     set envArg "tbp"
  875.     set arg "\[$envArg\]"
  876.     set theIndentation [getIndentation [getPos]]
  877.     append arg "\r$theIndentation\t\\centering"
  878.     set body ""
  879.     set macro [car $TeXmodeVars(boxMacroNames)]
  880.     if { $macro != "" } {
  881.         set restOfMacros [cdr $TeXmodeVars(boxMacroNames)]
  882.         if { ![llength $restOfMacros] } {
  883.             append body "\t\\$macro{••}\r"
  884.         } else {
  885.             set cmd [list prompt "Choose a box macro:"]
  886.             lappend cmd $macro "" 
  887.             foreach boxMacroName $TeXmodeVars(boxMacroNames) {
  888.                 lappend cmd $boxMacroName
  889.             }
  890.             catch $cmd macro
  891.             if {$macro == "cancel"} {
  892.                 message "operation canceled"
  893.                 return
  894.             } elseif {$macro == ""} {
  895.                 # do nothing
  896.             } else {
  897.                 append body "\t\\$macro{••}\r"
  898.             }
  899.         }
  900.     }
  901.     append body "\t\\caption{••}\r"
  902.     append body "\t\\label{fig:••}\r"
  903.     if { $macro == "" } {
  904.         wrapEnvironment $envName $arg $body
  905.     } else {
  906.         if {![insertEnvironment $envName $arg $body]} {return}
  907.     }
  908.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 "$envArg" [getPos]]
  909.     eval select $searchResult
  910.     message "Modify this argument?  (t=top; b=bottom; p=page; h=here; !=try harder)"
  911. }
  912. proc table {} {
  913.     set envName "table"
  914.     set envArg "tbp"
  915.     set arg "\[$envArg\]"
  916.     set theIndentation [getIndentation [getPos]]
  917.     append arg "\r$theIndentation\t\\centering"
  918.     # The following statement puts the caption at the top:
  919.     append arg "\r$theIndentation\t\\caption{••}"
  920.     # The following statement puts the caption at the bottom:
  921. #     set body "\t\\caption{••}\r"
  922.     append body "\t\\label{tbl:••}\r"
  923.     wrapEnvironment $envName $arg $body
  924.     set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 "$envArg" [getPos]]
  925.     eval select $searchResult
  926.     message "Modify this argument?  (t=top; b=bottom; p=page; h=here; !=try harder)"
  927. }
  928. proc buildRow {jmax} {
  929.     set txt "••"
  930.     for {set j 1} {$j < $jmax} {incr j} {
  931.         append txt " & ••"
  932.     }
  933.     return $txt
  934. }
  935. proc tabular {} {
  936.     global promptNoisily useStatusBar
  937.     set envName "tabular"
  938.     if {$promptNoisily && $useStatusBar} {beep}
  939.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  940.     if {$numberRows == "cancel"} {
  941.         return
  942.     } elseif {![isPositiveInteger $numberRows]} {
  943.         beep
  944.         message "invalid input:  unsigned, postive integer required"
  945.         return
  946.     }
  947.     if {$promptNoisily && $useStatusBar} {beep}
  948.     catch {sPrompt "$envName:  how many columns?" 3} numberCols
  949.     if {$numberCols == "cancel"} {
  950.         return
  951.     } elseif {![isPositiveInteger $numberCols]} {
  952.         beep
  953.         message "invalid input:  unsigned, postive integer required"
  954.         return
  955.     }
  956.     set arg "{|"
  957.     for {set j 1} {$j <= $numberCols} {incr j} {
  958.         append arg "c|"
  959.     }
  960.     append arg "}"
  961.     set body "\t\\hline\r"
  962.     for {set i 1} {$i <= $numberRows} {incr i} {
  963.         append body "\t[buildRow $numberCols]"
  964.         append body "  \\\\\r\t\\hline\r"
  965.     }
  966.     if {[insertEnvironment $envName $arg $body]} {
  967.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {(c|\|)+} [getPos]]
  968.         select [lindex $searchResult 0] [lindex $searchResult 1]
  969.         message "Modify this argument?"
  970.     }
  971. }
  972. proc verbatim {} { doWrapEnvironment "verbatim" }
  973. proc quote {} { doWrapEnvironment "quote" }
  974. proc quotation {} { doWrapEnvironment "quotation" }
  975. proc verse {} { doWrapEnvironment "verse" }
  976. proc flushleft {} { doWrapEnvironment "flushleft" }
  977. proc center {} { doWrapEnvironment "center" }
  978. proc flushright {} { doWrapEnvironment "flushright" }
  979.  
  980. #--------------------------------------------------------------------------
  981. # Boxes:
  982. #--------------------------------------------------------------------------
  983.  
  984. proc mbox {} {
  985.     if {[wrapObject "\\mbox{" "}••"]} {
  986.         message "mbox set"
  987.     } else {
  988.         message "enter text"
  989.     }
  990. }
  991. proc makebox {} {
  992.     if {[wrapObject "\\makebox\[••\]\[••\]{" "}••"]} {
  993.         message "makebox set; enter the width and position"
  994.     } else {
  995.         message "enter the width and position of the makebox, then the text"
  996.     }
  997. }
  998. proc fbox {} {
  999.     if {[wrapObject "\\fbox{" "}••"]} {
  1000.         message "fbox set"
  1001.     } else {
  1002.         message "enter text"
  1003.     }
  1004. }
  1005. proc framebox {} {
  1006.     if {[wrapObject "\\framebox\[••\]\[••\]{" "}••"]} {
  1007.         message "framebox set; enter the width and position"
  1008.     } else {
  1009.         message "enter the width and position of the framebox, then the text"
  1010.     }
  1011. }
  1012. proc newsavebox {} {
  1013.     if {[wrapObject "\\newsavebox{" "}••"]} {
  1014.         message "newsavebox defined"
  1015.     } else {
  1016.         message "enter the command name of the sbox or savebox"
  1017.     }
  1018. }
  1019. proc sbox {} {
  1020.     if {[wrapObject "\\sbox{••}{" "}••"]} {
  1021.         message "sbox set; enter the command name"
  1022.     } else {
  1023.         message "enter the command name of the sbox, then the text"
  1024.     }
  1025. }
  1026. proc savebox {} {
  1027.     if {[wrapObject "\\savebox{••}\[••\]\[••\]{" "}••"]} {
  1028.         message "savebox set; enter the command name"
  1029.     } else {
  1030.         message "enter the command name of the savebox"
  1031.     }
  1032. }
  1033. proc usebox {} {
  1034.     if {[wrapObject "\\usebox{" "}••"]} {
  1035.         message "usebox declared"
  1036.     } else {
  1037.         message "enter the command name of the sbox or savebox"
  1038.     }
  1039. }
  1040. proc raisebox {} {
  1041.     if {[wrapObject "\\raisebox{••}\[••\]\[••\]{" "}••"]} {
  1042.         message "raisebox set; enter the displacement"
  1043.     } else {
  1044.         message "enter the displacement of the raisebox"
  1045.     }
  1046. }
  1047. proc parbox {} {
  1048.     if {[wrapObject "\\parbox\[••\]\{••\}{" "}••"]} {
  1049.         message "parbox set; enter the position and width"
  1050.     } else {
  1051.         message "enter the position \[b|c|t\] and width of the parbox, then the text"
  1052.     }
  1053. }
  1054. proc minipage {} {
  1055.     set arg "\[••\]{••}"
  1056.     wrapEnvironment "minipage" $arg ""
  1057.     message "enter the position \[b|c|t\] of the minipage, then the width"
  1058. }
  1059. proc rule {} {
  1060.     insertObject "\\rule\[••\]\{••\}{••}••"
  1061.     message "enter the displacement of the rule, then width and height"
  1062. }
  1063.  
  1064. #--------------------------------------------------------------------------
  1065. # Misc:
  1066. #--------------------------------------------------------------------------
  1067.  
  1068. proc verb {} {
  1069.     if {[wrapObject "\\verb|" "|••"]} {
  1070.         message "verbatim text set"
  1071.     } else {
  1072.         message "enter verbatim text"
  1073.     }
  1074. }
  1075. proc footnote {} {
  1076.     if {[wrapObject "\\footnote{" "}••"]} {
  1077.         message "footnote set"
  1078.     } else {
  1079.         message "enter footnote"
  1080.     }
  1081. }
  1082. proc marginalNote {} {
  1083.     if {[wrapObject "\\marginpar{" "}••"]} {
  1084.         message "marginal note set"
  1085.     } else {
  1086.         message "enter marginal note"
  1087.     }
  1088. }
  1089.  
  1090. proc insertLabel {} {
  1091.     if {[wrapObject "\\label{" "}••"]} {
  1092.         message "label defined"
  1093.     } else {
  1094.         message "enter label"
  1095.     }
  1096. }
  1097. proc ref {} { 
  1098.     if {[wrapObject "\\ref{" "}••" 1]} {
  1099.         message "reference made"
  1100.     } else {
  1101.         message "enter reference label"
  1102.     }
  1103. }
  1104. proc pageref {} { 
  1105.     if {[wrapObject "\\pageref{" "}••" 1]} {
  1106.         message "page reference made"
  1107.     } else {
  1108.         message "enter page reference label"
  1109.     }
  1110. }
  1111. proc cite {} {
  1112.     if {[wrapObject "\\cite{" "}••" 1]} {
  1113.         message "citation made"
  1114.     } else {
  1115.         message "enter citation key"
  1116.     }
  1117. }
  1118. proc nocite {} {
  1119.     if {[wrapObject "\\nocite{" "}••"]} {
  1120.         message "citation added to the list"
  1121.     } else {
  1122.         message "enter citation key"
  1123.     }
  1124. }
  1125.  
  1126. # Insert an \item or a \bibitem, depending on the context.
  1127. proc insertItem {} {
  1128.     set command [eval getText [searchEnvironment]]
  1129.     set environment [extractCommandArg $command]
  1130.     switch $environment {
  1131.         "itemize" {
  1132.             set text "\\item  ••"
  1133.         }
  1134.         "enumerate" {
  1135.             set text "\\item  ••"
  1136.         }
  1137.         "description" {
  1138.             set text "\\item\[••\]  ••"
  1139.         }
  1140.         "thebibliography" {
  1141.             set text "\\bibitem{••}  ••"
  1142.         }
  1143.         default {
  1144.             beep
  1145.             message "insertItem: cursor in $environment environment"
  1146.             return
  1147.         }
  1148.     }
  1149.     set pos [getPos]
  1150.     # Indentation should mirror that of an existing \item
  1151.     # (if it exists)
  1152.     elec::Insertion [openingCarriageReturn]$text
  1153. }
  1154.  
  1155. proc quotes {} {
  1156.     if {[wrapObject "`" "'••"]} {
  1157.         message "text quoted"
  1158.     } else {
  1159.         message "enter text"
  1160.     }
  1161. }
  1162. proc dblQuotes {} {
  1163.     if {[wrapObject "``" "''••"]} {
  1164.         message "text double quoted"
  1165.     } else {
  1166.         message "enter text"
  1167.     }
  1168. }
  1169.  
  1170. proc texLogo {} {insertObject "\\TeX"}
  1171. proc latexLogo {} {insertObject "\\LaTeX"}
  1172. proc latex2eLogo {} {insertObject "\\LaTeXe"}
  1173. proc today {} {insertObject "\\today"}
  1174.  
  1175. proc dag {} {insertObject "\\dag"}
  1176. proc ddag {} {insertObject "\\ddag"}
  1177. proc sectionMark {} {insertObject "\\S"}
  1178. proc paragraphMark {} {insertObject "\\P"}
  1179. proc copyright {} {insertObject "\\copyright"}
  1180. proc pounds {} {insertObject "\\pounds"}
  1181.  
  1182.  
  1183. #############################################################################
  1184. # 
  1185. # Math Mode Macros
  1186. #
  1187. #############################################################################
  1188.  
  1189. #--------------------------------------------------------------------------
  1190. # Math Modes:
  1191. #--------------------------------------------------------------------------
  1192.  
  1193. proc texMath {} {
  1194.     checkMathMode "texMath" 0
  1195.     if {[wrapObject "$" "$••"]} {
  1196.         message "formula set"
  1197.     } else {
  1198.         message "enter formula"
  1199.     }
  1200. }
  1201. proc texDisplaymath {} {
  1202.     checkMathMode "texDisplaymath" 0
  1203.     if {[wrapObject "$$" "$$••"]} {
  1204.         message "displayed formula set"
  1205.     } else {
  1206.         message "enter displayed formula"
  1207.     }
  1208. }
  1209. proc latexMath {} {
  1210.     checkMathMode "latexMath" 0
  1211.     if {[wrapObject "\\( " " \\)••"]} {
  1212.         message "formula set"
  1213.     } else {
  1214.         message "enter formula"
  1215.     }
  1216. }
  1217. proc latexDisplaymath {} {
  1218.     checkMathMode "latexDisplaymath" 0
  1219.     if {[wrapObject "\\\[ " " \\\]••"]} {
  1220.         message "displayed formula set"
  1221.     } else {
  1222.         message "enter displayed formula"
  1223.     }
  1224. }
  1225.  
  1226. #--------------------------------------------------------------------------
  1227. # Math Style:
  1228. #--------------------------------------------------------------------------
  1229.  
  1230. proc doMathStyle {mathStyle description} {
  1231.     checkMathMode "$mathStyle" 1
  1232.     if {[wrapObject "\\$mathStyle{" "}••"]} {
  1233.         message "selected text is $description"
  1234.     } else {
  1235.         message "enter text to be $description"
  1236.     }
  1237. }
  1238. proc doUppercaseMathStyle {mathStyle description} {
  1239.     checkMathMode "$mathStyle" 1
  1240.     # Allow upper-case alphabetic arguments only:
  1241.     if {[isSelection] && (![isUppercase] || ![isAlphabetic])} {
  1242.         beep
  1243.         alertnote "argument to \\$mathStyle must be UPPERCASE alphabetic"
  1244.         return
  1245.     }
  1246.     if {[wrapObject "\\$mathStyle{" "}••"]} {
  1247.         message "selected text is $description"
  1248.     } else {
  1249.         message "enter text to be $description (UPPERCASE letters only)"
  1250.     }
  1251. }
  1252.  
  1253. #--------------------------------------------------------------------------
  1254. # Math Environments:
  1255. #--------------------------------------------------------------------------
  1256.  
  1257. proc math {} { checkMathMode "math" 0; doWrapEnvironment "math" }
  1258. proc displaymath {} {
  1259.     checkMathMode "displaymath" 0
  1260.     global TeXmodeVars
  1261.     if { $TeXmodeVars(useBrackets) } {
  1262.         doWrapStructure {\[} {} {\]}
  1263.     } else {
  1264.         doWrapEnvironment "displaymath"
  1265.     }
  1266. }
  1267. proc equation {} {
  1268.     checkMathMode "equation" 0
  1269.     set envName "equation"
  1270.     set body "\t\\label{eq:••}\r"
  1271.     if {[wrapEnvironment $envName "" $body]} {
  1272.         set msgText "equation wrapped"
  1273.     } else {
  1274.         set msgText "enter equation"
  1275.     }
  1276.     message $msgText
  1277. }
  1278. proc eqnarrayStar {} {
  1279.     global promptNoisily useStatusBar
  1280.     checkMathMode "eqnarrayStar" 0
  1281.     set envName "eqnarray*"
  1282.     if {$promptNoisily && $useStatusBar} {beep}
  1283.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1284.     if {$numberRows == "cancel"} {
  1285.         return
  1286.     } elseif {![isPositiveInteger $numberRows]} {
  1287.         beep
  1288.         message "invalid input:  unsigned, postive integer required"
  1289.         return
  1290.     }
  1291.     set row "\t[buildRow 3]"
  1292.     for {set i 1} {$i < $numberRows} {incr i} {
  1293.         append body $row
  1294.         append body "  \\\\\r"
  1295.     }
  1296.     append body $row
  1297.     append body "\r"
  1298.     if {[insertEnvironment $envName "" $body]} {
  1299.         message "type first item"
  1300.     }
  1301. }
  1302. proc eqnarray {} {
  1303.     global promptNoisily useStatusBar
  1304.     checkMathMode "eqnarray" 0
  1305.     set envName "eqnarray"
  1306.     if {$promptNoisily && $useStatusBar} {beep}
  1307.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1308.     if {$numberRows == "cancel"} {
  1309.         return
  1310.     } elseif {![isPositiveInteger $numberRows]} {
  1311.         beep
  1312.         message "invalid input:  unsigned, postive integer required"
  1313.         return
  1314.     }
  1315.     set row "\t[buildRow 3]\r\t\\label{eq:••}"
  1316.     for {set i 1} {$i < $numberRows} {incr i} {
  1317.         append body $row
  1318.         append body "  \\\\\r"
  1319.     }
  1320.     append body $row
  1321.     append body "\r"
  1322.     if {[insertEnvironment $envName "" $body]} {
  1323.         message "type first item"
  1324.     }
  1325. }
  1326. proc myArray {} {
  1327.     global promptNoisily useStatusBar
  1328.     checkMathMode "myArray" 1
  1329.     set envName "array"
  1330.     if {$promptNoisily && $useStatusBar} {beep}
  1331.     catch {sPrompt "$envName:  how many rows?" 3} numberRows
  1332.     if {$numberRows == "cancel"} {
  1333.         return
  1334.     } elseif {![isPositiveInteger $numberRows]} {
  1335.         beep
  1336.         message "invalid input:  unsigned, postive integer required"
  1337.         return
  1338.     }
  1339.     if {$promptNoisily && $useStatusBar} {beep}
  1340.     catch {sPrompt "$envName:  how many columns?" 3} numberCols
  1341.     if {$numberCols == "cancel"} {
  1342.         return
  1343.     } elseif {![isPositiveInteger $numberCols]} {
  1344.         beep
  1345.         message "invalid input:  unsigned, postive integer required"
  1346.         return
  1347.     }
  1348.     set arg "{"
  1349.     for {set j 1} {$j <= $numberCols} {incr j} {
  1350.         append arg "c"
  1351.     }
  1352.     append arg "}"
  1353.     set row "\t[buildRow $numberCols]"
  1354.     for {set i 1} {$i < $numberRows} {incr i} {
  1355.         append body $row
  1356.         append body "  \\\\\r"
  1357.     }
  1358.     append body $row
  1359.     append body "\r"
  1360.     if {[insertEnvironment $envName $arg $body]} {
  1361.         set searchResult [search -s -n -f 1 -m 0 -i 1 -r 1 {c+} [getPos]]
  1362.         select [lindex $searchResult 0] [lindex $searchResult 1]
  1363.         message "Modify this argument?  (c=center; l=left; r=right; p{width}; a{text})"
  1364.     }
  1365. }
  1366.  
  1367. #--------------------------------------------------------------------------
  1368. # Formulas:
  1369. #--------------------------------------------------------------------------
  1370.  
  1371. proc subscript {} {
  1372.     checkMathMode "subscript" 1
  1373.     if {[wrapObject "_{" "}••"]} {
  1374.         message "subscript set"
  1375.     } else {
  1376.         message "enter subscript"
  1377.     }
  1378. }
  1379. proc superscript {} {
  1380.     checkMathMode "superscript" 1
  1381.     if {[wrapObject "^{" "}••"]} {
  1382.         message "superscript set"
  1383.     } else {
  1384.         message "enter superscript"
  1385.     }
  1386. }
  1387. proc fraction {} {
  1388.     checkMathMode "fraction" 1
  1389.     set currentPos [getPos]
  1390.     if {[isSelection]} {
  1391.         set selection [getSelect]
  1392.         set args [split $selection /]
  1393.         set len [llength $args]
  1394.         deleteText $currentPos [selEnd]
  1395.         if {$len == 1} {
  1396.             insertObject "\\frac{$selection}{••}••"
  1397.             message "enter denominator"
  1398.         } else {
  1399.             set firstArg [lindex $args 0]
  1400.             set restArgs [lrange $args 1 [expr $len-1]]
  1401.             insertObject "\\frac{$firstArg}{[join $restArgs /]}"
  1402.             if {$len > 2} {message "beware of multiple /"}
  1403.         }
  1404.     } else {
  1405.         insertObject "\\frac{••}{••}••"
  1406.         message "enter numerator"
  1407.     }
  1408. }
  1409. proc squareRoot {} {
  1410.     checkMathMode "squareRoot" 1
  1411.     if {[wrapObject "\\sqrt{" "}••"]} {
  1412.         message "square root set"
  1413.     } else {
  1414.         message "enter formula"
  1415.     }
  1416. }
  1417. proc nthRoot {} {
  1418.     checkMathMode "nthRoot" 1
  1419.     if {[wrapObject "\\sqrt\[••\]{" "}••"]} {
  1420.         message "enter root"
  1421.     } else {
  1422.         message "enter root, then formula"
  1423.     }
  1424. }
  1425. proc oneParameter {} {
  1426.     checkMathMode "oneParameter" 1
  1427.     if {[wrapObject "\\••{" "}••"]} {
  1428.         message "enter command name"
  1429.     } else {
  1430.         message "enter command name, press <Tab>, enter argument"
  1431.     }
  1432. }
  1433. proc twoParameters {} {
  1434.     checkMathMode "twoParameters" 1
  1435.     if {[wrapObject "\\••{" "}{••}••"]} {
  1436.         message "enter command name"
  1437.     } else {
  1438.         message "enter command name, press <Tab>, enter argument, etc."
  1439.     }
  1440. }
  1441.  
  1442. #--------------------------------------------------------------------------
  1443. # Large Ops:
  1444. #--------------------------------------------------------------------------
  1445.  
  1446. proc insertLargeOp {commandName} {
  1447.     checkMathMode "$commandName" 1
  1448.     insertObject "\\$commandName\_{••}^{••}••"
  1449. }
  1450. proc sum {} {insertLargeOp "sum"}
  1451. proc prod {} {insertLargeOp "prod"}
  1452. proc coprod {} {insertLargeOp "coprod"}
  1453. proc int {} {insertLargeOp "int"}
  1454. proc oint {} {insertLargeOp "oint"}
  1455. proc bigcap {} {insertLargeOp "bigcap"}
  1456. proc bigcup {} {insertLargeOp "bigcup"}
  1457. proc bigsqcup {} {insertLargeOp "bigsqcup"}
  1458. proc bigvee {} {insertLargeOp "bigvee"}
  1459. proc bigwedge {} {insertLargeOp "bigwedge"}
  1460. proc bigodot {} {insertLargeOp "bigodot"}
  1461. proc bigotimes {} {insertLargeOp "bigotimes"}
  1462. proc bigoplus {} {insertLargeOp "bigoplus"}
  1463. proc biguplus {} {insertLargeOp "biguplus"}
  1464.  
  1465. #--------------------------------------------------------------------------
  1466. # Delimiters:
  1467. #--------------------------------------------------------------------------
  1468.  
  1469. proc delimitObject {leftDelim rightDelim} {
  1470.     if {[wrapObject $leftDelim $rightDelim]} {
  1471.         message "formula delimited"
  1472.     } else {
  1473.         message "enter formula"
  1474.     }
  1475. }
  1476. proc parentheses {} { checkMathMode "parentheses" 1; delimitObject "(" ")••" }
  1477. proc brackets {} { checkMathMode "brackets" 1; delimitObject "\[" "\]••" }
  1478. proc braces {} { checkMathMode "braces" 1; delimitObject "\\\{" "\\\}••" }
  1479. proc absoluteValue {} { checkMathMode "absoluteValue" 1; delimitObject "|" "|••" }
  1480. proc getDelims {} {
  1481.     catch {prompt "Choose delimiters:" "parentheses" "" "parentheses" \
  1482.                   "brackets" "braces" "angle brackets" "vertical bars" \
  1483.                   "double bars" "ceiling" "floor"} delimType
  1484.     if {$delimType != "cancel"} {
  1485.         switch $delimType {
  1486.             "parentheses" {
  1487.                 set leftDelim "("
  1488.                 set rightDelim ")"
  1489.             }
  1490.             "brackets" {
  1491.                 set leftDelim "\["
  1492.                 set rightDelim "\]"
  1493.             }
  1494.             "braces" {
  1495.                 set leftDelim "\\\{"
  1496.                 set rightDelim "\\\}"
  1497.             }
  1498.             "vertical bars" {
  1499.                 set leftDelim "|"
  1500.                 set rightDelim "|"
  1501.             }
  1502.             "double bars" {
  1503.                 set leftDelim "\\|"
  1504.                 set rightDelim "\\|"
  1505.             }
  1506.             "angle brackets" {
  1507.                 set leftDelim "\\langle"
  1508.                 set rightDelim "\\rangle"
  1509.             }
  1510.             "ceiling" {
  1511.                 set leftDelim "\\lceil"
  1512.                 set rightDelim "\\rceil"
  1513.             }
  1514.             "floor" {
  1515.                 set leftDelim "\\lfloor"
  1516.                 set rightDelim "\\rfloor"
  1517.             }
  1518.             default {
  1519.                 alertnote "\"$delimType\" not recognized"
  1520.                 return ""
  1521.             }
  1522.         }
  1523.         return [list $leftDelim $rightDelim]
  1524.     } else {return ""}
  1525. }
  1526. proc otherDelims {} {
  1527.     checkMathMode "otherDelims" 1
  1528.     set delims [getDelims]
  1529.     if {$delims != ""} {
  1530.         set leftDelim [lindex $delims 0]
  1531.         set rightDelim [lindex $delims 1]
  1532.         delimitObject "$leftDelim" "$rightDelim••"
  1533.     }
  1534. }
  1535. proc {half-openInterval} {} {
  1536.     checkMathMode "half-openInterval" 1; delimitObject "(" "\]••"
  1537. }
  1538. proc {half-closedInterval} {} {
  1539.     checkMathMode "half-closedInterval" 1; delimitObject "\[" ")••"
  1540. }
  1541.  
  1542. proc insertBigDelims {leftDelim rightDelim isMultiline} {
  1543.     checkMathMode "insertBigDelims" 1
  1544.     if {$isMultiline} {
  1545.         doWrapStructure $leftDelim "" $rightDelim
  1546.     } else {
  1547.         if { [wrapObject $leftDelim $rightDelim] } {
  1548.             message "formula delimited"
  1549.         } else {
  1550.             message "enter formula"
  1551.         }
  1552.     }
  1553. }
  1554. proc bigParens {} {
  1555.     checkMathMode "bigParens" 1; insertBigDelims "\\left(" "\\right)••" 0
  1556. }
  1557. proc multiBigParens {} {
  1558.     checkMathMode "multiBigParens" 1; insertBigDelims "\\left(" "\\right)••" 1
  1559. }
  1560. proc bigBrackets {} {
  1561.     checkMathMode "bigBrackets" 1; insertBigDelims "\\left\[" "\\right\]••" 0
  1562. }
  1563. proc multiBigBrackets {} {
  1564.     checkMathMode "multiBigBrackets" 1; insertBigDelims "\\left\[" "\\right\]••" 1
  1565. }
  1566. proc bigBraces {} {
  1567.     checkMathMode "bigBraces" 1; insertBigDelims "\\left\\\{" "\\right\\\}••" 0
  1568. }
  1569. proc multiBigBraces {} {
  1570.     checkMathMode "multiBigBraces" 1; insertBigDelims "\\left\\\{" "\\right\\\}••" 1
  1571. }
  1572. proc bigAbsValue {} {
  1573.     checkMathMode "bigAbsValue" 1; insertBigDelims "\\left|" "\\right|••" 0
  1574. }
  1575. proc multiBigAbsValue {} {
  1576.     checkMathMode "multiBigAbsValue" 1; insertBigDelims "\\left|" "\\right|••" 1
  1577. }
  1578. proc doOtherBigDelims {name isMultiline} {
  1579.     checkMathMode $name 1
  1580.     set delims [getDelims]
  1581.     if {$delims != ""} {
  1582.         append leftDelim "\\left" [lindex $delims 0]
  1583.         append rightDelim "\\right" [lindex $delims 1]
  1584.         insertBigDelims "$leftDelim" "$rightDelim••" $isMultiline
  1585.     }
  1586. }
  1587. proc otherBigDelims {} {
  1588.     doOtherBigDelims "otherBigDelims" 0
  1589. }
  1590. proc otherMultiBigDelims {} {
  1591.     doOtherBigDelims "otherMultiBigDelims" 1
  1592. }
  1593. proc bigLeftBrace {} {
  1594.     checkMathMode "bigLeftBrace" 1
  1595.     insertBigDelims "\\left\\\{" "\\right.••" 0
  1596. }
  1597. proc multiBigLeftBrace {} {
  1598.     checkMathMode "multiBigLeftBrace" 1
  1599.     insertBigDelims "\\left\\\{" "\\right.••" 1
  1600. }
  1601. proc doOtherMixedBigDelims {name isMultiline} {
  1602.     checkMathMode $name 1
  1603.     catch {prompt "Choose LEFT delimiter:" "parenthesis" "" "parenthesis" \
  1604.                   "bracket" "brace" "vertical bar" "double bar" \
  1605.                   "angle bracket" "ceiling" "floor" "slash" "backslash" \
  1606.                   "none"} delimType
  1607.     if {$delimType != "cancel"} {
  1608.         switch $delimType {
  1609.             "parenthesis" {set leftDelim "("}
  1610.             "bracket" {set leftDelim "\["}
  1611.             "brace" {set leftDelim "\\\{"}
  1612.             "vertical bar" {set leftDelim "|"}
  1613.             "double bar" {set leftDelim "\\|"}
  1614.             "angle bracket" {set leftDelim "\\langle"}
  1615.             "ceiling" {set leftDelim "\\lceil"}
  1616.             "floor" {set leftDelim "\\lfloor"}
  1617.             "slash" {set leftDelim "/"}
  1618.             "backslash" {set leftDelim "\\backslash"}
  1619.             "none" {set leftDelim "."}
  1620.             default {
  1621.                 alertnote "\"$delimType\" not recognized"
  1622.                 return
  1623.             }
  1624.         }
  1625.         catch {prompt "Choose RIGHT delimiter:" "parenthesis" "" "parenthesis" \
  1626.                       "bracket" "brace" "vertical bar" "double bar" \
  1627.                       "angle bracket" "ceiling" "floor" "slash" "backslash" \
  1628.                       "none"} delimType
  1629.         if {$delimType != "cancel"} {
  1630.             switch $delimType {
  1631.                 "parenthesis" {set rightDelim ")"}
  1632.                 "bracket" {set rightDelim "\]"}
  1633.                 "brace" {set rightDelim "\\\}"}
  1634.                 "vertical bar" {set rightDelim "|"}
  1635.                 "double bar" {set rightDelim "\\|"}
  1636.                 "angle bracket" {set rightDelim "\\rangle"}
  1637.                 "ceiling" {set rightDelim "\\rceil"}
  1638.                 "floor" {set rightDelim "\\rfloor"}
  1639.                 "slash" {set rightDelim "/"}
  1640.                 "backslash" {set rightDelim "\\backslash"}
  1641.                 "none" {set rightDelim "."}
  1642.                 default {
  1643.                     alertnote "\"$delimType\" not recognized"
  1644.                     return
  1645.                 }
  1646.             }
  1647.             insertBigDelims "\\left$leftDelim" "\\right$rightDelim••" $isMultiline
  1648.         }
  1649.     }
  1650. }
  1651. proc otherMixedBigDelims {} {
  1652.     doOtherMixedBigDelims "otherMixedBigDelims" 0
  1653. }
  1654. proc otherMultiMixedBigDelims {} {
  1655.     doOtherMixedBigDelims "otherMultiMixedBigDelims" 1
  1656. }
  1657.  
  1658. #--------------------------------------------------------------------------
  1659. # Accents:
  1660. #--------------------------------------------------------------------------
  1661.  
  1662. proc acute {} {
  1663.     checkMathMode "acute" 1
  1664.     if {[isSelection] > 1} {
  1665.         alertnote "Warning: only a single character may be accented!"
  1666.     }
  1667.     if {[wrapObject "\\acute{" "}••"]} {
  1668.         message "accent set"
  1669.     } else {
  1670.         message "enter one character"
  1671.     }
  1672. }
  1673. proc bar {} {
  1674.     checkMathMode "bar" 1
  1675.     if {[isSelection] > 1} {
  1676.         alertnote "Warning: only a single character may be accented!"
  1677.     }
  1678.     if {[wrapObject "\\bar{" "}••"]} {
  1679.         message "accent set"
  1680.     } else {
  1681.         message "enter one character"
  1682.     }
  1683. }
  1684. proc breve {} {
  1685.     checkMathMode "breve" 1
  1686.     if {[isSelection] > 1} {
  1687.         alertnote "Warning: only a single character may be accented!"
  1688.     }
  1689.     if {[wrapObject "\\breve{" "}••"]} {
  1690.         message "accent set"
  1691.     } else {
  1692.         message "enter one character"
  1693.     }
  1694. }
  1695. proc check {} {
  1696.     checkMathMode "check" 1
  1697.     if {[isSelection] > 1} {
  1698.         alertnote "Warning: only a single character may be accented!"
  1699.     }
  1700.     if {[wrapObject "\\check{" "}••"]} {
  1701.         message "accent set"
  1702.     } else {
  1703.         message "enter one character"
  1704.     }
  1705. }
  1706. proc dot {} {
  1707.     checkMathMode "dot" 1
  1708.     if {[isSelection] > 1} {
  1709.         alertnote "Warning: only a single character may be accented!"
  1710.     }
  1711.     if {[wrapObject "\\dot{" "}••"]} {
  1712.         message "accent set"
  1713.     } else {
  1714.         message "enter one character"
  1715.     }
  1716. }
  1717. proc ddot {} {
  1718.     checkMathMode "ddot" 1
  1719.     if {[isSelection] > 1} {
  1720.         alertnote "Warning: only a single character may be accented!"
  1721.     }
  1722.     if {[wrapObject "\\ddot{" "}••"]} {
  1723.         message "accent set"
  1724.     } else {
  1725.         message "enter one character"
  1726.     }
  1727. }
  1728. proc grave {} {
  1729.     checkMathMode "grave" 1
  1730.     if {[isSelection] > 1} {
  1731.         alertnote "Warning: only a single character may be accented!"
  1732.     }
  1733.     if {[wrapObject "\\grave{" "}••"]} {
  1734.         message "accent set"
  1735.     } else {
  1736.         message "enter one character"
  1737.     }
  1738. }
  1739. proc hat {} {
  1740.     checkMathMode "hat" 1
  1741.     if {[isSelection] > 1} {
  1742.         alertnote "Warning: only a single character may be accented!"
  1743.     }
  1744.     if {[wrapObject "\\hat{" "}••"]} {
  1745.         message "accent set"
  1746.     } else {
  1747.         message "enter one character"
  1748.     }
  1749. }
  1750. proc tilde {} {
  1751.     checkMathMode "tilde" 1
  1752.     if {[isSelection] > 1} {
  1753.         alertnote "Warning: only a single character may be accented!"
  1754.     }
  1755.     if {[wrapObject "\\tilde{" "}••"]} {
  1756.         message "accent set"
  1757.     } else {
  1758.         message "enter one character"
  1759.     }
  1760. }
  1761. proc vec {} {
  1762.     checkMathMode "vec" 1
  1763.     if {[isSelection] > 1} {
  1764.         alertnote "Warning: only a single character may be accented!"
  1765.     }
  1766.     if {[wrapObject "\\vec{" "}••"]} {
  1767.         message "accent set"
  1768.     } else {
  1769.         message "enter one character"
  1770.     }
  1771. }
  1772.  
  1773. proc widehat {} {
  1774.     checkMathMode "widehat" 1
  1775.     if {[isSelection] > 3} {
  1776.         alertnote "Warning: only a few characters may be accented!"
  1777.     }
  1778.     if {[wrapObject "\\widehat{" "}••"]} {
  1779.         message "accent set"
  1780.     } else {
  1781.         message "enter a few characters"
  1782.     }
  1783. }
  1784. proc widetilde {} {
  1785.     checkMathMode "widetilde" 1
  1786.     if {[isSelection] > 3} {
  1787.         alertnote "Warning: only a few characters may be accented!"
  1788.     }
  1789.     if {[wrapObject "\\widetilde{" "}••"]} {
  1790.         message "accent set"
  1791.     } else {
  1792.         message "enter a few characters"
  1793.     }
  1794. }
  1795.  
  1796.  
  1797. #--------------------------------------------------------------------------
  1798. # Grouping:
  1799. #--------------------------------------------------------------------------
  1800.  
  1801. proc underline {} {
  1802.     checkMathMode "underline" 1
  1803.     if {[wrapObject "\\underline{" "}••"]} {
  1804.         message "selection underlined"
  1805.     } else {
  1806.         message "enter text"
  1807.     }
  1808. }
  1809. proc overline {} {
  1810.     checkMathMode "overline" 1
  1811.     if {[wrapObject "\\overline{" "}••"]} {
  1812.         message "selection overlined"
  1813.     } else {
  1814.         message "enter text"
  1815.     }
  1816. }
  1817. proc underbrace {} {
  1818.     checkMathMode "underbrace" 1
  1819.     if {[wrapObject "\\underbrace{" "}••"]} {
  1820.         message "selection underbraced"
  1821.     } else {
  1822.         message "enter text"
  1823.     }
  1824. }
  1825. proc overbrace {} {
  1826.     checkMathMode "overbrace" 1
  1827.     if {[wrapObject "\\overbrace{" "}••"]} {
  1828.         message "selection overbraced"
  1829.     } else {
  1830.         message "enter text"
  1831.     }
  1832. }
  1833. proc overrightarrow {} {
  1834.     checkMathMode "overrightarrow" 1
  1835.     if {[wrapObject "\\overrightarrow{" "}••"]} {
  1836.         message "selection overrightarrowed"
  1837.     } else {
  1838.         message "enter text"
  1839.     }
  1840. }
  1841. proc overleftarrow {} {
  1842.     checkMathMode "overleftarrow" 1
  1843.     if {[wrapObject "\\overleftarrow{" "}••"]} {
  1844.         message "selection overleftarrowed"
  1845.     } else {
  1846.         message "enter text"
  1847.     }
  1848. }
  1849. proc stackrel {} {
  1850.     checkMathMode "stackrel" 1
  1851.     set currentPos [getPos]
  1852.     if {[insertObject "\\stackrel{••}{••}••"]} {
  1853.         message "1st arg scriptstyle"
  1854.     }
  1855. }
  1856.  
  1857. #--------------------------------------------------------------------------
  1858. # Spacing:
  1859. #--------------------------------------------------------------------------
  1860.  
  1861. proc negThin {} {checkMathMode "negThin" 1; insertObject "\\!"}
  1862. proc thin {} {checkMathMode "thin" 1; insertObject "\\,"}
  1863. proc medium {} {checkMathMode "medium" 1; insertObject "\\:"}
  1864. proc thick {} {checkMathMode "thick" 1; insertObject "\\;"}
  1865. proc quad {} {checkMathMode "quad" 1; insertObject "\\quad"}
  1866. proc qquad {} {checkMathMode "qquad" 1; insertObject "\\qquad"}
  1867. proc hspace {} {
  1868.     checkMathMode "hspace" 1
  1869.     if {[wrapObject "\\hspace{" "}••"]} {
  1870.         message "spacing set"
  1871.     } else {
  1872.         message "enter the desired horizontal spacing"
  1873.     }
  1874. }
  1875. proc vspace {} {
  1876.     checkMathMode "vspace" 1
  1877.     if {[wrapObject "\\vspace{" "}••"]} {
  1878.         message "spacing set"
  1879.     } else {
  1880.         message "enter the desired horizontal spacing"
  1881.     }
  1882. }
  1883. proc hfill {} {checkMathMode "hfill" 1; insertObject "\\hfill"}
  1884. proc vfill {} {checkMathMode "vfill" 1; insertObject "\\vfill"}
  1885. proc smallskip {} {checkMathMode "smallskip" 1; insertObject "\\smallskip"}
  1886. proc medskip {} {checkMathMode "medskip" 1; insertObject "\\medskip"}
  1887. proc bigskip {} {checkMathMode "bigskip" 1; insertObject "\\bigskip"}
  1888.  
  1889.